/**
 * 导出管理器
 * 统一管理导出流程，处理不同格式的导出逻辑
 */
import { ExportFormat, ExportOptions } from '../components/ExportDialog';
import { convertMarkdown, getFileExtension, getMimeType } from './formatConverter';

/**
 * 导出管理器接口
 */
export interface ExportManager {
  exportContent(
    content: string,
    title: string,
    format: string,
    options?: ExportOptions
  ): Promise<void>;
  
  getSupportedFormats(): ExportFormat[];
}

/**
 * 导出管理器实现类
 */
class ExportManagerImpl implements ExportManager {
  // 支持的导出格式
  private supportedFormats: ExportFormat[] = [
    { value: 'markdown', label: 'Markdown (.md)', requiresBackend: false },
    { value: 'html', label: 'HTML (.html)', requiresBackend: false },
    { value: 'wechat', label: '微信公众号格式 (.html)', requiresBackend: false },
    { value: 'txt', label: '纯文本 (.txt)', requiresBackend: false },
    { value: 'pdf', label: 'PDF文档 (.pdf)', requiresBackend: true },
    { value: 'docx', label: 'Word文档 (.docx)', requiresBackend: true }
  ];

  /**
   * 导出内容
   * @param content Markdown内容
   * @param title 文章标题
   * @param format 导出格式
   * @param options 导出选项
   */
  public async exportContent(
    content: string,
    title: string,
    format: string,
    options?: ExportOptions
  ): Promise<void> {
    if (!content.trim()) {
      throw new Error('内容不能为空');
    }

    const formatInfo = this.supportedFormats.find(f => f.value === format);
    if (!formatInfo) {
      throw new Error(`不支持的导出格式: ${format}`);
    }

    const filename = options?.filename || title || 'article';
    const includeTitle = options?.includeTitle ?? true;

    try {
      if (formatInfo.requiresBackend) {
        // 复杂格式需要后端处理
        await this.exportWithBackend(content, title, format, filename, includeTitle);
      } else {
        // 简单格式前端直接处理
        this.exportWithFrontend(content, title, format, filename, includeTitle);
      }
    } catch (error) {
      console.error('导出失败:', error);
      throw new Error(`导出失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  }

  /**
   * 前端直接处理导出
   * @param content Markdown内容
   * @param title 文章标题
   * @param format 导出格式
   * @param filename 文件名
   * @param includeTitle 是否包含标题
   */
  private exportWithFrontend(
    content: string,
    title: string,
    format: string,
    filename: string,
    includeTitle: boolean
  ): void {
    try {
      // 转换内容
      const processedContent = convertMarkdown(content, format, title, { includeTitle });
      const extension = getFileExtension(format);
      const mimeType = getMimeType(format);
      
      // 创建Blob对象
      const blob = new Blob([processedContent], { type: mimeType });
      
      // 创建下载链接
      const url = URL.createObjectURL(blob);
      const link = document.createElement('a');
      link.href = url;
      link.download = `${filename}.${extension}`;
      
      // 触发下载
      document.body.appendChild(link);
      link.click();
      
      // 清理
      setTimeout(() => {
        document.body.removeChild(link);
        URL.revokeObjectURL(url);
      }, 100);
    } catch (error) {
      console.error('前端导出失败:', error);
      throw error;
    }
  }

  /**
   * 通过后端API处理导出
   * @param content Markdown内容
   * @param title 文章标题
   * @param format 导出格式
   * @param filename 文件名
   * @param includeTitle 是否包含标题
   */
  private async exportWithBackend(
    content: string,
    title: string,
    format: string,
    filename: string,
    includeTitle: boolean
  ): Promise<void> {
    try {
      // 显示加载状态
      this.showLoading(true);
      
      // 调用后端API
      const response = await fetch('/api/export', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          content,
          title,
          format,
          filename,
          options: {
            includeTitle
          }
        })
      });
      
      if (!response.ok) {
        throw new Error(`服务器响应错误: ${response.status}`);
      }
      
      const data = await response.json();
      
      if (!data.success) {
        throw new Error(data.error || '导出失败');
      }
      
      // 处理返回的文件内容
      if (data.content) {
        let blob;
        
        // 检查是否是二进制文件
        if (data.isBinary && typeof data.content === 'string') {
          // 处理base64编码的二进制内容
          const byteCharacters = atob(data.content);
          const byteNumbers = new Array(byteCharacters.length);
          for (let i = 0; i < byteCharacters.length; i++) {
            byteNumbers[i] = byteCharacters.charCodeAt(i);
          }
          const byteArray = new Uint8Array(byteNumbers);
          blob = new Blob([byteArray], { type: data.contentType || getMimeType(format) });
        } else {
          // 对于文本类内容，前端直接创建Blob
          blob = new Blob([data.content], { type: data.contentType || getMimeType(format) });
        }
        
        // 创建下载链接
        const url = URL.createObjectURL(blob);
        const link = document.createElement('a');
        link.href = url;
        link.download = data.filename || `${filename}.${getFileExtension(format)}`;
        
        document.body.appendChild(link);
        link.click();
        
        setTimeout(() => {
          document.body.removeChild(link);
          URL.revokeObjectURL(url);
        }, 100);
      } else if (data.fileUrl) {
        // 对于直接提供下载链接的情况
        window.open(data.fileUrl, '_blank');
      }
    } catch (error) {
      console.error('后端导出失败:', error);
      throw error;
    } finally {
      // 隐藏加载状态
      this.showLoading(false);
    }
  }

  /**
   * 显示或隐藏加载状态
   * @param isLoading 是否显示加载状态
   */
  private showLoading(isLoading: boolean): void {
    // 这里可以实现加载状态的显示逻辑
    // 例如显示一个全局的加载指示器
    console.log(`加载状态: ${isLoading ? '显示' : '隐藏'}`);
  }

  /**
   * 获取支持的导出格式列表
   * @returns 导出格式列表
   */
  public getSupportedFormats(): ExportFormat[] {
    return [...this.supportedFormats];
  }
}

// 创建导出管理器的单例实例
const exportManager = new ExportManagerImpl();

export default exportManager;